package cn.tiger;

import java.security.AccessControlContext;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 *
 * 该类是一个线程安全的类，使用原子类 想看线程不安全版可以看 ThreadNotSafeNumIncrement
 * @see  ThreadNotSafeNumIncrement
 */
public class ThreadSafeNumIncrement {

    private AtomicInteger num = new AtomicInteger(0);

    private int getNum() {
        return num.getAndIncrement();
    }

    /**
     * incrementAndGet() 和 getAndIncrement() 都是自增 1，但前者返回自增后的值，后者返回自增前的值。
     * <br>
     * addAndGet(int delta) 和 getAndAdd(int delta) 都是增加指定的 delta，但前者返回增加后的值，后者返回增加前的值。
     */
    private void addNum() {
        num.incrementAndGet();
//        num.getAndIncrement();
//        num.addAndGet(1);
//        num.getAndAdd(1);
    }

    /**
     * 可以发现，结果等于100000 ，说明线程安全；
     * 线程安全的原因是使用了原子类，原子类是线程安全的，所以线程安全。
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 100000;

        ThreadSafeNumIncrement threadSafeNumIncrement = new ThreadSafeNumIncrement();
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(threadSafeNumIncrement::addNum).start();
            countDownLatch.countDown();
        }
        countDownLatch.await(); // 主线程等待子线程结束
        System.out.println(threadSafeNumIncrement.getNum());  // 100000、100000、100000
    }
}
